#include "analysisconfig.h"
#include "ui_analysisconfig.h"

AnalysisConfig::AnalysisConfig(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::AnalysisConfig)
{
    ui->setupUi(this);

    /* 初始化 */
    alys = new DataAnalysisService(); // 数据分析服务
    cusMsg = new CustomMessageBox(); // 自定义输入框

    this->selectedRow = -1; // 当前选中行
    this->curSelTar.targetName = ""; // 将当前选中靶基因名设为空，作为初始化内容

    ui->targetTable->hideColumn(4); // 设置id列隐藏

    /* 初始化当前选中的基因计算方式下标 */
    this->ctMethodIndex = alys->getCtDefaultValue(); // ct
    this->shuaiJianMethodIndex = alys->getShuaiJianDefaultValue(); // 衰减
    this->lvBoMethodIndex = alys->getLvBoDefaultValue(); // 滤波

    this->initComponents(); // 初始化控件

    this->curveOptimization = new curveoptimization();// 初始化曲线优化

    /* 启动渲染方法 */
    renderWholeDefaultSwitch(); // 默认设置开关
    renderCtFromConfig(); // Ct
    renderShuaiJianFromConfig(); // 衰减
    renderLvBoFromConfig(); // 滤波

    /* 使 QComboBox 的 下拉框 Item 样式生效 */
    ui->lvBoMethod->setView(new QListView());
    ui->shuaiJianMethod->setView(new QListView());
    ui->ctMethod->setView(new QListView());

    /* 设置靶基因表格样式 */
    // 设置表头字体样式
    ui->targetTable->horizontalHeader()->setStyleSheet("QHeaderView::section{"
                                                       "font-family: 'Alibaba PuHuiTi';"
                                                       "font-size: 14px;"
                                                       "}");
    ui->targetTable->setEditTriggers(QAbstractItemView::NoEditTriggers); // 表格不可编辑
    ui->targetTable->setSelectionBehavior(QAbstractItemView::SelectRows); // 选中一行
    ui->targetTable->setSelectionMode(QAbstractItemView::SingleSelection); // 只可单选一行
    ui->targetTable->verticalHeader()->setSectionResizeMode(QHeaderView::Stretch); // 表格自适应高度
    ui->targetTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch); // 表格自适应宽度

    /* 设置开关初始状态：全开 */
//    this->shuaiJianOn = true;
//    this->lvBoOn = true;
//    this->ctOn = true;
//    this->defaultOn = true;

//    connect(ui->curveoptimization, &QPushButton::clicked, this, &AnalysisConfig::slotCurveOptimization);

    /* 按钮关闭窗口 */
    connect(ui->ok, &QPushButton::clicked, this, [=](){ // 应用
        LOG << defaultJiXian;


        if(ui->targetTable->rowCount() != 0){
            this->updateConfigFile(); // 更新配置文件信息
            this->updateAnalysisTarget(); // 更新分析配置靶基因信息
            emit AnalysisConfig::updateAnalysisConfig(this->alysTarget); // 窗口关闭，发送信号，更新数据分析配置
        }

        /* 计算方式更新 */
        // 衰减计算方式
        this->shuaiJianMethodIndex = ui->shuaiJianMethod->currentIndex();
        // 滤波计算方式
        this->lvBoMethodIndex = ui->lvBoMethod->currentIndex();
        // ct计算方式
        this->ctMethodIndex = ui->ctMethod->currentIndex();

        this->close();
    });
    connect(ui->cancel, &QPushButton::clicked, this, [=](){ // 取消
        this->close();
    });

    /* 还原按钮 */
    connect(ui->reset, &QPushButton::clicked, this, [=](){ // 勾选默认设置，循环数改回
        if(ui->targetTable->rowCount() != 0 && this->selectedRow != -1){
            ui->jiXianBeginCycling->setValue(defaultJiXian[0]);
            ui->jiXianEndCycling->setValue(defaultJiXian[1]);
            ui->defaultSetting->setChecked(true);
        }

        /* 计算方式还原 */
        // 衰减计算方式
        if(ui->shuaiJianMethod->count() >= 1){
            ui->shuaiJianMethod->setCurrentIndex(0);
        }
        // 滤波计算方式
        if(ui->lvBoMethod->count() >= 1){
            ui->lvBoMethod->setCurrentIndex(0);
        }
        // ct计算方式
        if(ui->ctMethod->count() >= 2){
            ui->ctMethod->setCurrentIndex(1);
        }
    });

    /* 开关设置 */
    // 衰减
    connect(ui->shuaiJianSwitch, &QPushButton::clicked, this, &AnalysisConfig::shuaiJianSwitch);
    // 滤波
    connect(ui->lvBoSwitch, &QPushButton::clicked, this, [=](){
        this->lvBoSwitch();
        // 同步ct
        this->ctSwitch();
    });
    // ct
    connect(ui->ctSwitch, &QPushButton::clicked, this,[=](){
        this->ctSwitch();
        // 滤波
        this->lvBoSwitch();
    });
    // 默认设置
    connect(ui->defaultSetting, &QCheckBox::toggled, this, [=](bool checked){
        if(checked){ // 选中
            renderWholeYuZhiFromConfig("config");
            this->defaultOn = true;
            // 后边的输入框变为只读
            ui->yuZhiNumber->setReadOnly(true); // 阈值
            ui->jiXianBeginCycling->setReadOnly(true); // 开始基线
            ui->jiXianEndCycling->setReadOnly(true); // 结束基线
            // 改变单个target页面不可用
            for (auto i: alysTarget) {
                i.autoYuZhiOn = true;
                i.autoJiXianOn = true;
            }
            ui->singleTargetWidget->setEnabled(false);
            // 如果靶基因板里有数据，同步靶基因列表的基线范围
            QString startJiXian = ui->jiXianBeginCycling->text(),
                    endJiXian = ui->jiXianEndCycling->text();
            if(ui->targetTable->rowCount() != 0){
                int tarListSize = this->alysTarget.size();
                for(int i = 0; i < tarListSize; i++){
                    this->alysTarget[i].jiXianStart = startJiXian;
                    this->alysTarget[i].jiXianEnd = endJiXian;
                    ui->targetTable->item(i, 1)->setText("自动");
                    ui->targetTable->item(i, 2)->setText("自动");
                    ui->targetTable->item(i, 3)->setText("自动");
                }
                if(this->selectedRow != -1){
                    this->renderTargetTable(this->alysTarget);
                    this->updateSingleTargetInfo();
                }
            }
        }else { // 不选中
            this->defaultOn = false;
            // 后边的输入框变为可用
            ui->yuZhiNumber->setReadOnly(false); // 阈值
            ui->jiXianBeginCycling->setReadOnly(false); // 开始基线
            ui->jiXianEndCycling->setReadOnly(false); // 结束基线
            // 改变单个target页面可用
            ui->singleTargetWidget->setEnabled(true);
        }
    });

    /* 监听靶基因选中事件 */
    ui->targetTable->setMouseTracking(true); // 开启鼠标轨迹
    connect(ui->targetTable, &QTableWidget::itemSelectionChanged, this, [=](){
        this->updateSingleTargetInfo(); // 更新单个靶基因信息
    });

    /* 监听单个复选框选中状态 */
    connect(ui->singleAutoYuZhi, &QCheckBox::toggled, this, [=](bool checked){ // 阈值
        if(ui->targetTable->rowCount() > 0 && this->selectedRow != -1){
            this->alysTarget[curSelTarIndex].autoYuZhiOn = checked; // 写入状态
            if(checked){
                ui->targetTable->setItem(this->selectedRow, 1, new QTableWidgetItem("自动")); // 写table数据
            }else{
                ui->targetTable->setItem(this->selectedRow, 1, new QTableWidgetItem(this->curSelTar.yuZhi)); // 写table数据
            }
            this->updateSingleTargetInfo();
        }
    });

    connect(ui->singleAutoJiXian, &QCheckBox::toggled, this, [=](bool checked){ // 基线
        if(ui->targetTable->rowCount() > 0 && this->selectedRow != -1){
            this->alysTarget[curSelTarIndex].autoJiXianOn = checked; // 写入状态
            if(checked){
                ui->targetTable->setItem(this->selectedRow, 2, new QTableWidgetItem("自动")); // 写table数据
                ui->targetTable->setItem(this->selectedRow, 3, new QTableWidgetItem("自动")); // 写table数据
            }
            else {
                ui->targetTable->setItem(this->selectedRow, 2, new QTableWidgetItem(this->curSelTar.jiXianStart)); // 写table数据
                ui->targetTable->setItem(this->selectedRow, 3, new QTableWidgetItem(this->curSelTar.jiXianEnd)); // 写table数据
            }
            this->updateSingleTargetInfo();
        }
    });

    /* 监听单个输入框输入事件 */
    connect(ui->singleYuZhiNumber, &QLineEdit::textChanged, this, [=](QString text){ // 阈值
        // 同步靶基因板的数据
        if(this->selectedRow != -1){
            ui->targetTable->setItem(this->selectedRow, 1, new QTableWidgetItem(text));
        }
    });
    connect(ui->singleJiXianBeginCycling, &QSpinBox::textChanged, this, [=](QString start){ // 基线开始
        // 同步靶基因板的数据
        if(this->selectedRow != -1){
            ui->targetTable->setItem(this->selectedRow, 2, new QTableWidgetItem(start));
        }
    });
    connect(ui->singleJiXianEndCycling, &QSpinBox::textChanged, this, [=](QString end){ // 基线结束
        // 同步靶基因板的数据
        if(this->selectedRow != -1){
            ui->targetTable->setItem(this->selectedRow, 3, new QTableWidgetItem(end));
        }
    });
    connect(ui->jiXianBeginCycling, &QSpinBox::textChanged, this, [=](QString text) {
        defaultJiXian[0] = text.toInt();
    });
    connect(ui->jiXianEndCycling, &QSpinBox::textChanged, this, [=](QString text) {
        defaultJiXian[1] = text.toInt();
    });

}

AnalysisConfig::~AnalysisConfig()
{
    alys = nullptr;
    cusMsg = nullptr;
    delete ui;
}

/* 设置开关图标和状态 */
void AnalysisConfig::setSwitch(QPushButton *switchBtn, SwitchStatus Switch, bool* itemSwitchOn){
    switch (Switch) {
    case 0: // 关
        switchBtn->setIcon(QIcon(":icon/icon/switch_off"));
        *itemSwitchOn = false;
        break;
    case 1: // 开
        switchBtn->setIcon(QIcon(":icon/icon/switch_on"));
        *itemSwitchOn = true;
        break;
    }
}

/* 渲染配置文件中的衰减信息 */
void AnalysisConfig::renderShuaiJianFromConfig(){
    LOG << "this->shuaiJianMethodIndex" << this->shuaiJianMethodIndex;

    QString shuaiJianSwitch = ""; // 开关
    QList<QString> shuaiJianMethod; // 衰减方法

    /* 渲染开关 */
    shuaiJianSwitch = alys->getShuaiJianStatus();
    if(shuaiJianSwitch == "0"){ // 开关关闭
        this->setSwitch(ui->shuaiJianSwitch, SwitchStatus::OFF, &(this->shuaiJianOn));
        ui->shuaiJianMethod->setEnabled(false); // 选择方法框不可用
    }else if (shuaiJianSwitch == "1") { // 开关打开
        this->setSwitch(ui->shuaiJianSwitch, SwitchStatus::ON, &(this->shuaiJianOn));
        ui->shuaiJianMethod->setEnabled(true); // 选择方法框可用
    }

    /* 渲染衰减方法 */
    shuaiJianMethod = alys->getShuaiJianMethod();
    ui->shuaiJianMethod->blockSignals(true); // 阻止信号
    foreach(QString method ,shuaiJianMethod){
        ui->shuaiJianMethod->addItem(method); // 渲染衰减方法
    }

    // 设置当前衰减计算方法
//    if(ui->shuaiJianMethod->count() >= 1){ // 边界判断
//        if(this->shuaiJianMethodIndex == -1){ // 初始计算方法判断
//            this->shuaiJianMethodIndex = 1;
//        }
//        this->shuaiJianMethodIndex = alys->getShuaiJianDefaultValue(); // 配置文件默认值

        ui->shuaiJianMethod->setCurrentIndex(this->shuaiJianMethodIndex);
//    }
    ui->shuaiJianMethod->blockSignals(false); // 解除信号
}

/* 渲染配置文件中的滤波信息 */
void AnalysisConfig::renderLvBoFromConfig(){
    LOG << "this->lvBoMethodIndex" << this->lvBoMethodIndex;

    QString lvBoSwitch = ""; // 开关
    QList<QString> lvBoMethod; // 滤波方法

    /* 渲染开关 */
    lvBoSwitch = alys->getLvBoStatus();
    if(lvBoSwitch == "0"){ // 开关关闭
        this->setSwitch(ui->lvBoSwitch, SwitchStatus::OFF, &(this->lvBoOn));
        ui->lvBoMethod->setEnabled(false); // 选择方法框不可用
    }else if (lvBoSwitch == "1") { // 开关打开
        this->setSwitch(ui->lvBoSwitch, SwitchStatus::ON, &(this->lvBoOn));
        ui->lvBoMethod->setEnabled(true); // 选择方法框可用
    }

    /* 渲染滤波方法 */
    lvBoMethod = alys->getLvBoMethod();
    ui->lvBoMethod->blockSignals(true); // 阻止信号
    foreach(QString method ,lvBoMethod){
        ui->lvBoMethod->addItem(method); // 渲染衰减方法
    }

    // 设置当前滤波计算方法
//    if(ui->lvBoMethod->count() >= 1){ // 边界判断
//        if(this->lvBoMethodIndex == -1){ // 初始计算方法判断
//            this->lvBoMethodIndex = 0;
//        }
//        this->lvBoMethodIndex = alys->getLvBoDefaultValue();
//        LOG << this->lvBoMethodIndex;
        ui->lvBoMethod->setCurrentIndex(this->lvBoMethodIndex);
//    }
    ui->lvBoMethod->blockSignals(false); // 解除信号
}

/* 渲染配置文件中Ct值信息 */
void AnalysisConfig::renderCtFromConfig(){
    LOG << "this->ctMethodIndex" << this->ctMethodIndex;

    QList<QString> ctMethod; // ct值计算方法

    /* 渲染开关 */
    QString ctSwitch = alys->getCtStatus();
    if(ctSwitch == "0"){ // 开关关闭
        this->setSwitch(ui->ctSwitch, SwitchStatus::OFF, &(this->ctOn));
        ui->ctMethod->setEnabled(false); // 选择方法框不可用
    }else if (ctSwitch == "1") { // 开关打开
        this->setSwitch(ui->ctSwitch, SwitchStatus::ON, &(this->ctOn));
        ui->ctMethod->setEnabled(true); // 选择方法框可用
    }

    /* 渲染ct值计算方法 */
    ctMethod = alys->getCtMethod();
    ui->ctMethod->blockSignals(true);
    foreach(QString method ,ctMethod){
        ui->ctMethod->addItem(method);
    }

    // 设置当前ct值计算方法
//    if(ui->ctMethod->count() >= 2){ // 边界判断
//        if(this->ctMethodIndex == -1){ // 初始计算方法判断
//            this->ctMethodIndex = 1;
//        }
//        this->ctMethodIndex = alys->getCtDefaultValue();
//        LOG << this->ctMethodIndex;
        ui->ctMethod->setCurrentIndex(this->ctMethodIndex);
//    }
    ui->ctMethod->blockSignals(false);
}

/* 衰减开关 */
void AnalysisConfig::shuaiJianSwitch(){
    if(this->shuaiJianOn){ // 开：改为关
        this->setSwitch(ui->shuaiJianSwitch, SwitchStatus::OFF, &(this->shuaiJianOn));
        ui->shuaiJianMethod->setEnabled(false); // 选择方法框不可用
    }else{ // 关：改为开
        this->setSwitch(ui->shuaiJianSwitch, SwitchStatus::ON, &(this->shuaiJianOn));
        ui->shuaiJianMethod->setEnabled(true); // 选择方法框可用
    }
}

/* 滤波开关 */
void AnalysisConfig::lvBoSwitch(){
    if(this->lvBoOn){ // 开：改为关
        this->setSwitch(ui->lvBoSwitch, SwitchStatus::OFF, &(this->lvBoOn));
        ui->lvBoMethod->setEnabled(false); // 选择方法框不可用
    }else{ // 关：改为开
        this->setSwitch(ui->lvBoSwitch, SwitchStatus::ON, &(this->lvBoOn));
        ui->lvBoMethod->setEnabled(true); // 选择方法框可用
    }
}

/* ct开关 */
void AnalysisConfig::ctSwitch(){
    if(this->ctOn){ // 开：改为关
        this->setSwitch(ui->ctSwitch, SwitchStatus::OFF, &(this->ctOn));
        ui->ctMethod->setEnabled(false); // 选择方法框不可用
    }else{ // 关：改为开
        this->setSwitch(ui->ctSwitch, SwitchStatus::ON, &(this->ctOn));
        ui->ctMethod->setEnabled(true); // 选择方法框可用
    }
}

/* 渲染统一设置的默认配置开关(1-开/0-关) */
void AnalysisConfig::renderWholeDefaultSwitch(){
    QString status = alys->getDefaultSetting(); // 获取默认配置开关状态
    if(status == "1") { // 开
        ui->defaultSetting->setChecked(true); // 默认设置 复选框选中
        // 后边的输入框变为只读
        ui->yuZhiNumber->setReadOnly(true); // 阈值
        ui->jiXianBeginCycling->setReadOnly(true); // 开始基线
        ui->jiXianEndCycling->setReadOnly(true); // 结束基线
        // 改变单个target页面不可用
        ui->singleTargetWidget->setEnabled(false);
    }else {
        ui->defaultSetting->setChecked(false); // 默认设置 复选框不选中
        // 后边的输入框变为只读
        ui->yuZhiNumber->setReadOnly(false); // 阈值
        ui->jiXianBeginCycling->setReadOnly(false); // 开始基线
        ui->jiXianEndCycling->setReadOnly(false); // 结束基线
        // 改变单个target页面可用
        ui->singleTargetWidget->setEnabled(true);
    }
    this->renderWholeJiXianFromConfig(); // 设置默认基线
    this->renderWholeYuZhiFromConfig("default"); // 设置默认阈值
}

/* 渲染配置文件中阈值信息 */
void AnalysisConfig::renderWholeYuZhiFromConfig(QString peizhi){
    QList<int> jiXianList = alys->getJiXianSetting(); // 获取配置文件中的基线组
    /* 设置基线 */
    if(jiXianList.size() == 2){ // 配置文件基线正确
        if (peizhi.contains("default")) {
            ui->jiXianBeginCycling->setValue(defaultJiXian[0]);
            ui->jiXianEndCycling->setValue(defaultJiXian[1]);
        } else if (peizhi.contains("config")) {
            ui->jiXianBeginCycling->setValue(jiXianList[0]);
            ui->jiXianEndCycling->setValue(jiXianList[1]);
        }
    }else { // 配置文件基线不正确
        ui->jiXianBeginCycling->setValue(0);
        ui->jiXianEndCycling->setValue(0);
    }
}

/* 渲染配置文件中基线信息 */
void AnalysisConfig::renderWholeJiXianFromConfig(){
    QString yuZhi = alys->getYuZhiSetting(); // 获取配置文件中的阈值
    // 设置默认输入框数值
    ui->yuZhiNumber->setText(yuZhi);
}

/* 返回数据分析配置 */
std::tuple<QHash<QString, int>, double> AnalysisConfig::getAnalysisConfig(){
    QHash<QString, int> resHash; // 结果Hash
    std::tuple<QHash<QString, int>, double> res; // 结果元组

    int shuaiJianSwitch = 0, // 衰减开关
            shuaiJianMethod = 0, // 衰减方法
            lvBoSwitch = 0, // 滤波开关
            lvBoMethod = 0, // 滤波方法
            yuZhiConfig = 0, // 阈值配置
            jiXianConfig = 0, // 基线配置
            jiXianStart = 0, // 基线开始循环数
            jiXianEnd = 0, // 基线结束循环数
            ctSwitch = 0, // ct开关
            ctMethod = 0; // cT值计算方法
    double yuZhiNum = 0; // 阈值数;

    shuaiJianSwitch = this->shuaiJianOn ? 1 : 0;
    shuaiJianMethod = ui->shuaiJianMethod->currentIndex();
    //    shuaiJianMethod = 0; // 目前没有方法，回传0

    lvBoSwitch = this->lvBoOn ? 1 : 0;
    lvBoMethod = ui->lvBoMethod->currentIndex();

    jiXianStart = ui->jiXianBeginCycling->value();
    jiXianEnd = ui->jiXianEndCycling->value();

    LOG << "jixianstart" << jiXianStart << "jixianend" << jiXianEnd;

    ctMethod = ui->ctMethod->currentIndex();
    ctSwitch = this->ctOn ? 1 : 0;
    //    ctMethod = 1; // 现在仅为交叉法，下标为1

    /* 结果导入 */
    resHash.insert("shuaiJianSwitch", shuaiJianSwitch);
    resHash.insert("lvBoSwitch", lvBoSwitch);
    resHash.insert("yuZhiConfig", yuZhiConfig);
    resHash.insert("jiXianConfig", jiXianConfig);

    resHash.insert("shuaiJianMethod", shuaiJianMethod);
    resHash.insert("lvBoMethod", lvBoMethod);
    resHash.insert("jiXianStart", jiXianStart);
    resHash.insert("jiXianEnd", jiXianEnd);

    resHash.insert("ctSwitch", ctSwitch);
    resHash.insert("ctMethod", ctMethod);

    /* 结果组合 */
    res = {resHash, yuZhiNum};

    return res;
}

/* 更新分析配置靶基因信息 */
void AnalysisConfig::updateAnalysisTarget(){
    int tarListSize = this->alysTarget.size(); // 获取数据分析靶基因表大小
    /* 开始更新靶基因信息 */
    for(int i = 0; i < tarListSize; i++){
        int tarId = this->alysTarget[i].id; // 靶基因id
        int selRowCnt = ui->targetTable->rowCount(); // 靶基因表的行数
        int selRow = -1; // 记录行

        // 遍历表
        for(int j = 0; j < selRowCnt; j++){
            // 如果当前行写入的id 与 当前的靶基因id一致，则为要更新的靶基因行数据
            if(tarId == ui->targetTable->item(j, 4)->text().toInt()){
                selRow = j;
                break;
            }
        }



        // 全按id渲染
        // 阈值
        QString yuZhi = ui->targetTable->item(selRow, 1)->text();
        if(yuZhi != "自动"){ // 如果不为自动阈值
            this->alysTarget[i].autoYuZhiOn = false; // 关闭自动阈值设置
            this->alysTarget[i].yuZhi = yuZhi; // 写入阈值
        }else {
            this->alysTarget[i].autoYuZhiOn = true; // 开启自动阈值设置
        }
        // 基线
        QString start = ui->targetTable->item(selRow, 2)->text(); // 开始
        QString end = ui->targetTable->item(selRow, 3)->text(); // 结束

        if(start != "自动" && end != "自动"){
            this->alysTarget[i].autoJiXianOn = false; // 关闭自动基线设置
            this->alysTarget[i].jiXianStart = start; // 写入开始循环数
            this->alysTarget[i].jiXianEnd = end; // 写入结束循环数
        }else {
            this->alysTarget[i].autoJiXianOn = true; // 开启自动基线设置
            this->alysTarget[i].jiXianStart = QString::number(defaultJiXian[0]); // 写入开始循环数
            this->alysTarget[i].jiXianEnd = QString::number(defaultJiXian[1]); // 写入结束循环数
        }

    }
}

/* 验证关闭时的数据合法性 */
bool AnalysisConfig::checkDataValidation(){

    /* 都满足，关闭窗口 */
    return true;
}

/* 更新配置文件信息 */
void AnalysisConfig::updateConfigFile(){
    /* 开关 */
    // 阈值
    this->shuaiJianOn ? alys->setShuaiJianStatus(QString::number(SwitchStatus::ON)) :
                        alys->setShuaiJianStatus(QString::number(SwitchStatus::OFF));
    // 滤波
    this->lvBoOn ? alys->setLvBoStatus(QString::number(SwitchStatus::ON)) :
                   alys->setLvBoStatus(QString::number(SwitchStatus::OFF));
    // ct
    this->ctOn ? alys->setCtStatus(QString::number(SwitchStatus::ON)) :
                 alys->setCtStatus(QString::number(SwitchStatus::OFF));
    // 默认设置
    this->defaultOn ? alys->setDefaultSetting(QString::number(SwitchStatus::ON)) :
                      alys->setDefaultSetting(QString::number(SwitchStatus::OFF));
}

/* 更新靶基因表右侧单个靶基因信息 */
void AnalysisConfig::updateSingleTargetInfo(){
    // 获取选中的行下标
    QItemSelectionModel *selection = ui->targetTable->selectionModel();
    QModelIndexList indexList = selection->selectedIndexes();
    this->selectedRow = indexList[0].row();
    // 获取当前选中的靶基因id
    int tarId = ui->targetTable->item(selectedRow, 4)->text().toInt();

    LOG << "tarId" << tarId << this->alysTarget.size();

    // 遍历整个靶基因组，找到与选中id对应的靶基因
    for(int i = 0; i < this->alysTarget.size(); i++){
        if(this->alysTarget[i].id == tarId){
            this->curSelTar = this->alysTarget[i]; // 再赋值
            curSelTarIndex = i; // 获取其靶基因所在的List的下标
            break;
        }
    }

    // 更新左侧阈值设置信息
    ui->target->setText(ui->targetTable->item(selectedRow, 0)->text());

    // 渲染复选框
    if(this->curSelTar.autoYuZhiOn){ // 自动阈值
        ui->singleAutoYuZhi->blockSignals(true);
        ui->singleAutoYuZhi->setChecked(true);
        ui->singleAutoYuZhi->blockSignals(false);
        ui->singleYuZhiNumber->blockSignals(true);
        ui->singleYuZhiNumber->setText("自动"); // 阈值
        ui->singleYuZhiNumber->blockSignals(false);
        ui->singleYuZhiNumber->setReadOnly(true); // 只读开
    }else {
        ui->singleAutoYuZhi->blockSignals(true);
        ui->singleAutoYuZhi->setChecked(false);
        ui->singleAutoYuZhi->blockSignals(false);
        ui->singleYuZhiNumber->blockSignals(true);
        ui->singleYuZhiNumber->setText(ui->targetTable->item(selectedRow, 1)->text()); // 阈值
        ui->singleYuZhiNumber->blockSignals(false);
        ui->singleYuZhiNumber->setReadOnly(false); // 只读关
    }

    if(this->curSelTar.autoJiXianOn){ // 自动基线
        ui->singleAutoJiXian->blockSignals(true);
        ui->singleAutoJiXian->setChecked(true);
        ui->singleAutoJiXian->blockSignals(false);
        // 基线输入框只读
        ui->singleJiXianBeginCycling->setReadOnly(true);
        ui->singleJiXianEndCycling->setReadOnly(true);
        ui->singleJiXianBeginCycling->blockSignals(true);
        ui->singleJiXianEndCycling->blockSignals(true);
        ui->singleJiXianBeginCycling->setValue(this->defaultJiXian[0]); // 基线开始
        ui->singleJiXianEndCycling->setValue(defaultJiXian[1]); // 基线结束
        ui->singleJiXianBeginCycling->blockSignals(false);
        ui->singleJiXianEndCycling->blockSignals(false);
    }else {
        ui->singleAutoJiXian->blockSignals(true);
        ui->singleAutoJiXian->setChecked(false);
        ui->singleAutoJiXian->blockSignals(false);
        // 基线输入框只读关
        ui->singleJiXianBeginCycling->setReadOnly(false);
        ui->singleJiXianEndCycling->setReadOnly(false);
        ui->singleJiXianBeginCycling->blockSignals(true);
        ui->singleJiXianEndCycling->blockSignals(true);
        ui->singleJiXianBeginCycling->setValue(this->curSelTar.jiXianStart.toInt()); // 基线开始
        ui->singleJiXianEndCycling->setValue(this->curSelTar.jiXianEnd.toInt()); // 基线结束
        ui->singleJiXianBeginCycling->blockSignals(false);
        ui->singleJiXianEndCycling->blockSignals(false);
    }
}

/* 渲染分析配置页面靶基因板 */
void AnalysisConfig::renderTargetTable(QList<AnalysisTarget> alysTarget){
    this->alysTarget = alysTarget; // 写入全局变量
    int alysTargetSize = alysTarget.size(); // 获取数据分析靶基因列表
    QList<AnalysisTarget> tAlyTar1, tAlyTar2, tAlyTar3, tAlyTar4; // 临时分析靶基因变量
    QList<AnalysisTarget> tAlyTarofTheRest; // 剩余临时分析靶基因变量
    QHash<int, QList<AnalysisTarget>> alyTarNameHavingNumber; // 记录带有数字的分析靶基因序o列


//    排序begin
    // 根据靶基因名称，排序分析靶基因
    for(int i = 0; i < alysTargetSize; i++){
        if(alysTarget[i].targetName.contains("1")){ // 名字中带有1的
            tAlyTar1.append(alysTarget[i]);
        }
        else if(alysTarget[i].targetName.contains("2")){ // 名字中带有2的
            tAlyTar2.append(alysTarget[i]);
        }
        else if(alysTarget[i].targetName.contains("3")){ // 名字中带有3的
            tAlyTar3.append(alysTarget[i]);
        }
        else if(alysTarget[i].targetName.contains("4")){ // 名字中带有4的
            tAlyTar4.append(alysTarget[i]);
        }else { // 名字中没有数字的
            tAlyTarofTheRest.append(alysTarget[i]);
        }
        LOG << "alysTarget[i].jiXianEnd" << alysTarget[i].jiXianEnd << alysTarget[i].targetName;
    }
    alyTarNameHavingNumber.insert(1, tAlyTar1); // 写入hash
    alyTarNameHavingNumber.insert(2, tAlyTar2); // 写入hash
    alyTarNameHavingNumber.insert(3, tAlyTar3); // 写入hash
    alyTarNameHavingNumber.insert(4, tAlyTar4); // 写入hash
    alyTarNameHavingNumber.insert(0, tAlyTarofTheRest); // 写入hash


    for(int i = 0; i < alysTargetSize; i++){
        alysTarget[i].targetName = QString("target%1").arg(i+1);
    }

    ui->targetTable->setRowCount(alysTargetSize); // 渲染靶基因表行
    // 渲染结果页面靶基因表
    for(int i = 0; i < alysTarget.size(); i++){
        ui->targetTable->setItem(i, 0, new QTableWidgetItem(alysTarget[i].targetName)); // 靶基因名
        if(ui->defaultSetting->checkState() == Qt::Checked){ // 如果默认设置被选中，那么渲染自动
            alysTarget[i].autoYuZhiOn = true; // 自动阈值
            alysTarget[i].autoJiXianOn = true; // 自动基线
        }

        // 阈值自动和基线自动
        if(alysTarget[i].autoYuZhiOn){ // 阈值
            ui->targetTable->setItem(i, 1, new QTableWidgetItem("自动")); // 阈值
        }else {
            ui->targetTable->setItem(i, 1, new QTableWidgetItem(alysTarget[i].yuZhi)); // 阈值
        }
        if(alysTarget[i].autoJiXianOn){ // 基线
            ui->targetTable->setItem(i, 2, new QTableWidgetItem("自动")); // 基线开始
            ui->targetTable->setItem(i, 3, new QTableWidgetItem("自动")); // 基线结束
        }else {
            ui->targetTable->setItem(i, 2, new QTableWidgetItem(alysTarget[i].jiXianStart)); // 基线开始
            ui->targetTable->setItem(i, 3, new QTableWidgetItem(alysTarget[i].jiXianEnd)); // 基线结束
        }

        // 靶基因ID
        ui->targetTable->setItem(i, 4, new QTableWidgetItem(QString::number(alysTarget[i].id)));
    }

//    this->alysTarget = alysTarget; // 赋值
}

/* 控件初始化 */
void AnalysisConfig::initComponents(){
    // 初始化选中行
    this->selectedRow = -1;

    // 清空下拉框
    ui->shuaiJianMethod->clear();
    ui->lvBoMethod->clear();
    ui->ctMethod->blockSignals(true);
    ui->ctMethod->clear();
    ui->ctMethod->blockSignals(false);
    // 清空所有输入框
    ui->yuZhiNumber->clear(); // 统一阈值
    ui->jiXianBeginCycling->clear(); // 统一基线开始
    ui->jiXianEndCycling->clear(); // 统一基线结束

    ui->singleYuZhiNumber->clear(); // 单个阈值
    ui->singleJiXianBeginCycling->clear(); // 单个基线开始
    ui->singleJiXianEndCycling->clear(); // 单个基线结束
    ui->singleAutoYuZhi->setChecked(false); // 单个阈值
    ui->singleAutoJiXian->setChecked(false); // 单个基线

    ui->target->clear(); // 清空靶基因名

    ui->targetTable->blockSignals(true); // 阻塞信号
    ui->targetTable->setRowCount(0); // 清空靶基因表
    ui->targetTable->blockSignals(false); // 阻塞信号结束
}

/* 关闭窗口事件 */
void AnalysisConfig::closeEvent(QCloseEvent *event){
    bool isValid = this->checkDataValidation(); // 检测数据合法性
    if(!isValid){ // 数据不合法
        event->ignore();
    }else { // 合法，关闭窗口
        event->accept();
    }

}

/* 打开窗口事件 */
void AnalysisConfig::showEvent(QShowEvent *){
    ui->jiXianBeginCycling->setValue(defaultJiXian[0]); // 基线开始
    ui->jiXianEndCycling->setValue(defaultJiXian[1]); // 基线结束
    this->initComponents(); // 初始化控件

    /* 启动渲染方法 */
    renderWholeDefaultSwitch(); // 默认设置开关
    renderCtFromConfig(); // Ct
    renderShuaiJianFromConfig(); // 衰减
    renderLvBoFromConfig(); // 滤波
    emit AnalysisConfig::sigGetAnalysisTarget(); // 发送信号，通知回传分析配置靶基因
}

// 曲线优化功能
void AnalysisConfig::slotCurveOptimization() {
    curveOptimization->show();
    this->hide();
}
